home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / Envelope.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  7.6 KB  |  193 lines  |  [TEXT/KAHL]
  1. /* Envelope.h */
  2.  
  3. #ifndef Included_Envelope_h
  4. #define Included_Envelope_h
  5.  
  6. /* Envelope module depends on */
  7. /* MiscInfo.h */
  8. /* Audit */
  9. /* Debug */
  10. /* Definitions */
  11. /* Memory */
  12. /* Frequency */
  13.  
  14. /* this type is made so it can be changed */
  15. typedef float EnvNumberType;
  16.  
  17. /* possible patterns of the envelope transition */
  18. typedef enum
  19.     {
  20.         eEnvelopeLinearInAmplitude EXECUTE(= -13241),
  21.         eEnvelopeLinearInDecibels
  22.     } EnvTransTypes;
  23.  
  24. /* these are the kinds of sustain points there are */
  25. typedef enum
  26.     {
  27.         eEnvelopeSustainPointSkip EXECUTE(= -2341), /* hold this point, skip here on release */
  28.         eEnvelopeReleasePointSkip, /* don't hold this point, but skip here on release */
  29.         eEnvelopeSustainPointNoSkip, /* hold this point, but don't skip ahead on release */
  30.         eEnvelopeReleasePointNoSkip /* don't hold this point and don't skip ahead on release */
  31.     } SustainTypes;
  32.  
  33. #ifdef ShowMeEnvelopeRec
  34. typedef struct
  35.     {
  36.         /* transition duration (seconds) */
  37.         EnvNumberType                            Duration;
  38.         /* destination amplitude (0..1) */
  39.         EnvNumberType                            EndPoint;
  40.         /* transition type */
  41.         EnvTransTypes                            TransitionType;
  42.         /* adjustment factors */
  43.         EnvNumberType                            Accent1Amp;
  44.         EnvNumberType                            Accent2Amp;
  45.         EnvNumberType                            Accent3Amp;
  46.         EnvNumberType                            Accent4Amp;
  47.         EnvNumberType                            FrequencyAmpRolloff;
  48.         EnvNumberType                            FrequencyAmpNormalization;
  49.         EnvNumberType                            Accent1Rate;
  50.         EnvNumberType                            Accent2Rate;
  51.         EnvNumberType                            Accent3Rate;
  52.         EnvNumberType                            Accent4Rate;
  53.         EnvNumberType                            FrequencyRateRolloff;
  54.         EnvNumberType                            FrequencyRateNormalization;
  55.     } EnvStepRec;
  56. struct EnvelopeRec
  57.     {
  58.         /* number of envelope phases. 0 phases means the envelope produces constant value */
  59.         long                                            NumPhases;
  60.         /* list of definitions for each transition phase */
  61.         EnvStepRec*                                PhaseArray;
  62.         /* phase at which first sustain occurs. (released by key-up) */
  63.         /* if the value of this is N, then sustain will occur after phase N has */
  64.         /* completed.  if it is 0, then sustain will occur after phase 0 has completed. */
  65.         /* if it is -1, then sustain will not occur.  sustain may not be NumPhases since */
  66.         /* that would be the end of envelope and would be the same as final value hold. */
  67.         long                                            SustainPhase1;
  68.         SustainTypes                            SustainPhase1Type;
  69.         /* phase at which second sustain occurs. */
  70.         long                                            SustainPhase2;
  71.         SustainTypes                            SustainPhase2Type;
  72.         /* phase at which note-end sustain occurs */
  73.         long                                            SustainPhase3;
  74.         SustainTypes                            SustainPhase3Type;
  75.         /* phase used to align envelope timing with other envelopes */
  76.         long                                            Origin;
  77.  
  78.         EnvNumberType                            OverallScalingFactor;
  79.     };
  80. #else
  81. struct EnvelopeRec;
  82. #endif
  83. typedef struct EnvelopeRec EnvelopeRec;
  84.  
  85. /* create a new envelope record with nothing in it */
  86. EnvelopeRec*                        NewEnvelope(void);
  87.  
  88. /* dispose of an envelope record */
  89. void                                        DisposeEnvelope(EnvelopeRec* Envelope);
  90.  
  91. /* find out how many frames there are in the envelope */
  92. long                                        GetEnvelopeNumFrames(EnvelopeRec* Envelope);
  93.  
  94. /* set a release point.  -1 means this release point is ignored */
  95. void                                        EnvelopeSetReleasePoint1(EnvelopeRec* Envelope, long Release,
  96.                                                     SustainTypes ReleaseType);
  97. void                                        EnvelopeSetReleasePoint2(EnvelopeRec* Envelope, long Release,
  98.                                                     SustainTypes ReleaseType);
  99. void                                        EnvelopeSetReleasePoint3(EnvelopeRec* Envelope, long Release,
  100.                                                     SustainTypes ReleaseType);
  101.  
  102. /* get the value of a release point */
  103. long                                        GetEnvelopeReleasePoint1(EnvelopeRec* Envelope);
  104. long                                        GetEnvelopeReleasePoint2(EnvelopeRec* Envelope);
  105. long                                        GetEnvelopeReleasePoint3(EnvelopeRec* Envelope);
  106.  
  107. /* get the release point type */
  108. SustainTypes                        GetEnvelopeReleaseType1(EnvelopeRec* Envelope);
  109. SustainTypes                        GetEnvelopeReleaseType2(EnvelopeRec* Envelope);
  110. SustainTypes                        GetEnvelopeReleaseType3(EnvelopeRec* Envelope);
  111.  
  112. /* set the origin of the envelope */
  113. void                                        EnvelopeSetOrigin(EnvelopeRec* Envelope, long Origin);
  114.  
  115. /* get the origin from the envelope */
  116. long                                        GetEnvelopeOrigin(EnvelopeRec* Envelope);
  117.  
  118. /* set the value of an adjustment */
  119. void                                        EnvelopeSetAccent1Amp(EnvelopeRec* Envelope,
  120.                                                     double Val, long Phase);
  121. void                                        EnvelopeSetAccent2Amp(EnvelopeRec* Envelope,
  122.                                                     double Val, long Phase);
  123. void                                        EnvelopeSetAccent3Amp(EnvelopeRec* Envelope,
  124.                                                     double Val, long Phase);
  125. void                                        EnvelopeSetAccent4Amp(EnvelopeRec* Envelope,
  126.                                                     double Val, long Phase);
  127. void                                        EnvelopeSetFreqAmpRolloff(EnvelopeRec* Envelope,
  128.                                                     double Val, long Phase);
  129. void                                        EnvelopeSetFreqAmpNormalization(EnvelopeRec* Envelope,
  130.                                                     double Val, long Phase);
  131. void                                        EnvelopeSetAccent1Rate(EnvelopeRec* Envelope,
  132.                                                     double Val, long Phase);
  133. void                                        EnvelopeSetAccent2Rate(EnvelopeRec* Envelope,
  134.                                                     double Val, long Phase);
  135. void                                        EnvelopeSetAccent3Rate(EnvelopeRec* Envelope,
  136.                                                     double Val, long Phase);
  137. void                                        EnvelopeSetAccent4Rate(EnvelopeRec* Envelope,
  138.                                                     double Val, long Phase);
  139. void                                        EnvelopeSetFreqRateRolloff(EnvelopeRec* Envelope,
  140.                                                     double Val, long Phase);
  141. void                                        EnvelopeSetFreqRateNormalization(EnvelopeRec* Envelope,
  142.                                                     double Val, long Phase);
  143.  
  144. /* get the value of an adjustment */
  145. EnvNumberType                        GetEnvelopeAccent1Amp(EnvelopeRec* Envelope, long Phase);
  146. EnvNumberType                        GetEnvelopeAccent2Amp(EnvelopeRec* Envelope, long Phase);
  147. EnvNumberType                        GetEnvelopeAccent3Amp(EnvelopeRec* Envelope, long Phase);
  148. EnvNumberType                        GetEnvelopeAccent4Amp(EnvelopeRec* Envelope, long Phase);
  149. EnvNumberType                        GetEnvelopeFreqAmpRolloff(EnvelopeRec* Envelope, long Phase);
  150. EnvNumberType                        GetEnvelopeFreqAmpNormalization(EnvelopeRec* Envelope, long Phase);
  151. EnvNumberType                        GetEnvelopeAccent1Rate(EnvelopeRec* Envelope, long Phase);
  152. EnvNumberType                        GetEnvelopeAccent2Rate(EnvelopeRec* Envelope, long Phase);
  153. EnvNumberType                        GetEnvelopeAccent3Rate(EnvelopeRec* Envelope, long Phase);
  154. EnvNumberType                        GetEnvelopeAccent4Rate(EnvelopeRec* Envelope, long Phase);
  155. EnvNumberType                        GetEnvelopeFreqRateRolloff(EnvelopeRec* Envelope, long Phase);
  156. EnvNumberType                        GetEnvelopeFreqRateNormalization(EnvelopeRec* Envelope, long Phase);
  157.  
  158. /* set the overall amplitude scaling factor */
  159. void                                        EnvelopeSetOverallAmplitude(EnvelopeRec* Envelope,
  160.                                                     double OverallAmplitude);
  161.  
  162. /* get the overall amplitude */
  163. EnvNumberType                        GetEnvelopeOverallAmplitude(EnvelopeRec* Envelope);
  164.  
  165. /* insert a new phase at the specified position.  Values are undefined */
  166. MyBoolean                                EnvelopeInsertPhase(EnvelopeRec* Envelope, long Index);
  167.  
  168. /* delete a phase from the envelope */
  169. void                                        EnvelopeDeletePhase(EnvelopeRec* Envelope, long Index);
  170.  
  171. /* set a new value for the specified phase's duration */
  172. void                                        EnvelopeSetPhaseDuration(EnvelopeRec* Envelope, long Index,
  173.                                                     double Duration);
  174.  
  175. /* get the duration from the specified envelope position */
  176. EnvNumberType                        GetEnvelopePhaseDuration(EnvelopeRec* Envelope, long Index);
  177.  
  178. /* set a new value for the specified phase's ultimate value */
  179. void                                        EnvelopeSetPhaseFinalValue(EnvelopeRec* Envelope, long Index,
  180.                                                     double FinalValue);
  181.  
  182. /* get the phase's ultimate value */
  183. EnvNumberType                        GetEnvelopePhaseFinalValue(EnvelopeRec* Envelope, long Index);
  184.  
  185. /* set the value for a phase's transition type */
  186. void                                        EnvelopeSetPhaseTransitionType(EnvelopeRec* Envelope, long Index,
  187.                                                     EnvTransTypes TransitionType);
  188.  
  189. /* obtain the value in a phase's transition type */
  190. EnvTransTypes                        GetEnvelopePhaseTransitionType(EnvelopeRec* Envelope, long Index);
  191.  
  192. #endif
  193.